import { Request, Response } from 'express';
import { UserModel } from '../models/user';
import { generateToken, JwtPayload } from '../utils/jwt';
import bcrypt from 'bcryptjs';
import logger from '../utils/logger'
import svgCaptcha from 'svg-captcha'
const saltRounds = 10;
export class UserController {
  private userModel: UserModel;

  constructor() {
    this.userModel = new UserModel();
  }

  // 用户注册
  register = async (req: Request, res: Response): Promise<void> => {
    try {
      const { username, password, code } = req.body;
      if (!username) {
        res.status(200).json({
          code: 400,
          message: 'username不能为空'
        });
        return;
      }
      if (!password) {
        res.status(200).json({
          code: 400,
          message: 'password不能为空'
        });
        return;
      }
      const register_ip = req.ip || '127.0.0.1';
      if (!code) {
        res.status(200).json({
          code: 400,
          message: '验证码不能为空'
        });
        return;
      }
      // 从 session 中获取存储的验证码
      const storedCaptcha = req.session.captcha;
      if (!storedCaptcha) {
        res.status(200).json({
          code: 401,
          message: '验证码已过期，请重新获取'
        });
        return
      }
       // 检查ip是否已存在
      const existingIp = await this.userModel.findByUserIp(register_ip);
      if (existingIp) {
        res.status(200).json({ 
          code: 402,
          message: 'ip已被注册'
        });
        return;
      }
      // 检查用户是否已存在
      const existingUser = await this.userModel.findByUsername(username);
      if (existingUser) {
        res.status(200).json({ 
          code: 403,
          message: '用户名已存在'
        });
        return;
      }

      // 加密密码
      
      const hashedPassword = await bcrypt.hash(`${password}`, saltRounds);
      
      // 创建用户
      const userId = await this.userModel.create({ username, password: hashedPassword, register_ip });

      // 获取创建的用户信息（包含时间戳和索引）
      const newUser = await this.userModel.findByUserId(userId);

      if (!newUser) {
        res.status(500).json({ message: '用户创建失败', userId });
        return;
      }

      // 生成 JWT 令牌
      // const tokenPayload: JwtPayload = {
      //   userId: newUser.userId!,
      //   username: newUser.username,
      //   userIndex: newUser.userIndex
      // };
      // const token = generateToken(tokenPayload);

      res.status(200).json({
        code: 200,
        message: '用户注册成功!'
      });
    } catch (error) {
      logger.error(error)
      res.status(500).json({ message: '注册失败！' });
    }
  };

  // // 用户登录
  login = async (req: Request, res: Response): Promise<void> => {
    try {
      const { username, password } = req.body;

      // 查找用户
      const user = await this.userModel.findByUsername(username);
      if (!user) {
        res.status(200).json({
          code: 400,
          message: '用户名或密码错误'
        });
        return;
      }

      // 验证密码
      const validPassword = await bcrypt.compare(`${password}`, user.password);
      if (!validPassword) {
        res.status(200).json({
          code: 400,
          message: '用户名或密码错误'
        });
        return;
      }

      // 生成 JWT 令牌
      const tokenPayload: JwtPayload = {
        userId: user.userId!,
        username: user.username,
        userIndex: user.userIndex,
        isAdmin: user.userId === process.env.ADMIN_USER_ID,
      };
      const token = generateToken(tokenPayload);

      res.status(200).json({
        message: '登录成功',
        code: 200,
        data: {
          token
        }
      });
    } catch (error) {
      console.error('登录错误:', error);
      res.status(500).json({ message: '服务器内部错误' });
    }
  };

  // // 获取当前用户信息
  getProfile = async (req: Request, res: Response): Promise<void> => {
    try {
      const user = req.user!;
      
      // 从数据库获取最新的用户信息
      const userInfo = await this.userModel.findByUserId(user.userId);
      
      if (!userInfo) {
        res.status(200).json({ code: 403, message: '非法访问' });
        return;
      }

      res.status(200).json({
        code: 200,
        message: '获取成功',
        data: {
          userId: userInfo.userId,
          userIndex: userInfo.userIndex,
          username: userInfo.username,
          created_at: userInfo.created_at,
          updated_at: userInfo.updated_at
        }
      });
    } catch (error) {
      console.error('获取用户信息错误:', error);
      res.status(500).json({ message: '服务器内部错误' });
    }
  };
  // 获取验证码接口
  getCaptcha = async (req: Request, res: Response): Promise<void> => {
    try {
      const captcha = svgCaptcha.createMathExpr({
        noise: 3, // 干扰线数量
        color: true,
        background: '#f0f0f0',
        width: 120,
        height: 40
      })
      // 将验证码文本存储到 session 中
      req.session.captcha = captcha.text;
      req.session.save();
       // 设置响应头
      res.type('svg');
      res.status(200).send(captcha.data);
    } catch (error) {
      console.error('获取验证码错误:', error);
      res.status(500).json({ message: '服务器内部错误' });
    }
  }
  // // 修改密码
  changePassInfo = async (req: Request, res: Response): Promise<void> => {
    try {
      const user = req.user!;
      const { oldPassword, newPassword, username } = req.body;

      // 验证当前密码
      const userInfo = await this.userModel.findByUserId(user.userId);
      if (!userInfo) {
        res.status(200).json({ code: 403, message: '非法访问' });
        return;
      }

      const validPassword = await bcrypt.compare(`${oldPassword}`, userInfo.password);
      if (!validPassword) {
        res.status(200).json({ code: 400, message: '旧密码错误' });
        return;
      }

      // 加密新密码
      const hashedNewPassword = await bcrypt.hash(`${newPassword}`, saltRounds);
      const upData = {
        password: hashedNewPassword,
        updated_at: new Date().toLocaleString(),
        userId: user.userId,
        username
      }
      // 更新密码
      const success = await this.userModel.updateUser(upData);
      if (success) {
        // 获取更新后的用户信息
        res.json({
          message: '密码修改成功',
          code: 200
        });
      } else {
        res.status(400).json({ message: '密码修改失败' });
      }
    } catch (error) {
      console.error('修改密码错误:', error);
      res.status(500).json({ message: '服务器内部错误' });
    }
  };
  adminChangePassInfo = async (req: Request, res: Response): Promise<void> => {
    try {
      const user = req.user!;
      if (!user.isAdmin) {
        res.status(200).json({ code: 403, message: '非法请求！' });
        return;
      }
      const { password, username } = req.body;
      if (!password) {
        res.status(200).json({
          code: 400,
          message: '新密码不得为空！'
        });
        return
      }
      const userInfo = await this.userModel.findByUsername(username);
      if (!userInfo) {
        res.status(200).json({
          code: 400,
          message: '用户不存在！'
        });
        return;
      }
      const pwd = await bcrypt.hash(`${password}`, saltRounds)
      const upData = {
        password: pwd,
        updated_at: new Date().toLocaleString(),
        userId: userInfo.userId,
        username: userInfo.username
      }
      const resData = await this.userModel.updateUserPwd(upData);
      if (resData) {
        res.json({
          message: '密码修改成功',
          code: 200,
          password,
          pwd
        });
      } else {
        res.status(400).json({ message: '密码修改失败' });
      }
    } catch (error) {
      console.error('修改密码错误:', error);
      res.status(500).json({ message: '服务器内部错误' });
    }
  };
  // // 更新用户信息
  // updateProfile = async (req: Request, res: Response): Promise<void> => {
  //   try {
  //     const user = req.user!;
  //     const { email, display_name } = req.body;

  //     // 构建更新数据
  //     const updateData: any = {};
  //     if (email) updateData.email = email;
  //     if (display_name) updateData.display_name = display_name;

  //     // 如果有要更新的字段
  //     if (Object.keys(updateData).length > 0) {
  //       const success = await this.userModel.update(user.userId, updateData);
        
  //       if (success) {
  //         // 获取更新后的用户信息
  //         const updatedUser = await this.userModel.findByUserId(user.userId);
  //         res.json({
  //           message: '用户信息更新成功',
  //           user: {
  //             userId: updatedUser?.userId,
  //             userIndex: updatedUser?.userIndex,
  //             username: updatedUser?.username,
  //             created_at: updatedUser?.created_at,
  //             updated_at: updatedUser?.updated_at
  //           }
  //         });
  //       } else {
  //         res.status(400).json({ message: '更新失败' });
  //       }
  //     } else {
  //       res.status(400).json({ message: '没有提供要更新的字段' });
  //     }
  //   } catch (error) {
  //     console.error('更新用户信息错误:', error);
  //     res.status(500).json({ message: '服务器内部错误' });
  //   }
  // };

  

  // // 获取所有用户列表（按注册顺序排序）
  // getAllUsers = async (req: Request, res: Response): Promise<void> => {
  //   try {
  //     const users = await this.userModel.findAll();
      
  //     res.json({
  //       total: users.length,
  //       users: users.map(user => ({
  //         userId: user.userId,
  //         userIndex: user.userIndex,
  //         username: user.username,
  //         created_at: user.created_at,
  //         updated_at: user.updated_at
  //       }))
  //     });
  //   } catch (error) {
  //     console.error('获取用户列表错误:', error);
  //     res.status(500).json({ message: '服务器内部错误' });
  //   }
  // };

  // // 根据注册索引获取用户
  // getUserByIndex = async (req: Request, res: Response): Promise<void> => {
  //   try {
  //     const { index } = req.params;
  //     const userIndex = parseInt(index);

  //     if (isNaN(userIndex) || userIndex < 1) {
  //       res.status(400).json({ message: '无效的用户索引' });
  //       return;
  //     }

  //     const user = await this.userModel.findByUserIndex(userIndex);
      
  //     if (!user) {
  //       res.status(404).json({ message: '用户不存在' });
  //       return;
  //     }

  //     res.json({
  //       user: {
  //         userId: user.userId,
  //         userIndex: user.userIndex,
  //         username: user.username,
  //         created_at: user.created_at,
  //         updated_at: user.updated_at
  //       }
  //     });
  //   } catch (error) {
  //     console.error('获取用户错误:', error);
  //     res.status(500).json({ message: '服务器内部错误' });
  //   }
  // };

  // // 获取用户统计信息
  // getUserStats = async (req: Request, res: Response): Promise<void> => {
  //   try {
  //     const totalUsers = await this.userModel.getTotalCount();
      
  //     res.json({
  //       totalUsers,
  //       message: `当前共有 ${totalUsers} 位注册用户`
  //     });
  //   } catch (error) {
  //     console.error('获取用户统计错误:', error);
  //     res.status(500).json({ message: '服务器内部错误' });
  //   }
  // };
}